home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 001-025 / disk_009 / proff / proff01.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  11KB  |  741 lines
  1.  
  2.  
  3.  
  4.  
  5. #include <stdio.h>
  6. #include <ctype.h>
  7. #include "proff.h"
  8. #include "debug.h"
  9.  
  10. /*
  11.  * bold - bold face or overstrike a line
  12.  *
  13.  */
  14. bold(buf,tbuf,size)
  15. char buf[];
  16. char tbuf[];
  17. int  size;
  18. {
  19.     int  i,j;
  20.     dprintf("bold  ");
  21.  
  22.     j = 0;
  23.     for (i = 0; buf[i] != '\n' && j < size - 2; i++) {
  24.         tbuf[j] = buf[i];
  25.         j++;
  26.         if (buf[i] != ' ' && buf[i] != '\t' &&
  27.             buf[i] != BACKSPACE ) {
  28.             tbuf[j] = BACKSPACE;
  29.             tbuf[j+1] = tbuf[j-1];
  30.             j += 2;
  31.         }
  32.     }
  33.     tbuf[j] = '\n';
  34.     tbuf[j+1] = '\0';
  35.     strcpy(buf,tbuf);
  36. }
  37.  
  38. /*
  39.  * brkeol - end current filled line
  40.  *
  41.  */
  42. brkeol()
  43. {
  44.     dprintf("brkeol  ");
  45.     if (outp > 0) {
  46.         outbuf[outp] = '\n';
  47.         outbuf[outp+1] = EOS;
  48.         put(outbuf);
  49.     }
  50.     outp = 0;
  51.     outw = 0;
  52.     outwds = 0;
  53. }
  54.  
  55. /*
  56.  * center - center a line by setting tival
  57.  *
  58.  */
  59. center(buf)
  60. char buf[];
  61. {
  62.     int    i;
  63.  
  64.     dprintf("center  ");
  65.  
  66.     i = (rmval + tival - width(buf)) / 2;
  67.     tival = (i > 0) ? i : 0;
  68. }
  69.  
  70. /*
  71.  * doroff - format text in file fp
  72.  *
  73.  */
  74. doroff(fp)
  75. FILE *fp;
  76. {
  77.     char inbuf[INSIZE];
  78.  
  79.     infile[0] = fp;
  80.     for (level = 0; level > -1; level--) {
  81.         while (ngetln(inbuf, infile[level]) != EOF) {
  82.             if (inbuf[0] == cchar)    /* a command */
  83.                 command(inbuf);
  84.             else {
  85. #ifdef rainbow
  86.                 if (biosb(2))
  87.                     exit(0);
  88. #endif
  89.                 text(inbuf);
  90.                 p_txtlines++;
  91.             }
  92.         }
  93.         if (level > 0 && infile[level] > 0) {
  94.             fclose(infile[level]);
  95.             if (verbose)
  96.                 fprintf(stderr,"       done.\n");
  97.         }
  98.     }
  99. }
  100.  
  101. /*
  102.  * gettl - copy title from buf to ttl
  103.  *
  104.  * modifies lim
  105.  */
  106. gettl(buf,ttl,lim)
  107. char *buf;
  108. char *ttl;
  109. int lim[];
  110. {
  111.     while (!isspace(*buf))
  112.         buf++;
  113.     while (isspace(*buf))
  114.         buf++;
  115.     strcpy(ttl,buf);
  116.     lim[0] = inval;
  117.     lim[1] = rmval;
  118. }
  119.  
  120. /*
  121.  * getwrb - get a word INCLUDING the trailing blanks
  122.  *
  123.  */
  124. int
  125. getwrb(in,i,out)
  126. char in[];
  127. char out[];
  128. int *i;
  129. {
  130.     int j,k;
  131.     dprintf("getval  ");
  132.     k = *i;
  133.     j = 0;
  134.     while (in[k] != EOS && in[k] != ' ' &&
  135.         in[k] != '\t' && in[k] != '\n') {
  136.         out[j] = in[k];
  137.         k++;
  138.         j++;
  139.     }
  140.     while (in[k] == ' ') {
  141.         out[j] = ' ';
  142.         k++;
  143.         j++;
  144.     }
  145.     *i = k;
  146.     out[j] = EOS;
  147.     return(j);
  148. }
  149.  
  150.  
  151. /*
  152.  * gfield - get next tab or title field
  153.  *
  154.  */
  155. int
  156. gfield(buf, i, n, temp, delim)
  157. char buf[];
  158. int *i;
  159. int n;
  160. char temp[];
  161. char delim;
  162. {
  163.     int j,k;
  164.  
  165.     dprintf("gfield  ");
  166.     j = 0;
  167.     k = *i;
  168.     if (n > 0) {
  169.         if (buf[k] == delim)
  170.             k++;
  171.         while (buf[k] != delim && buf[k] != EOS && buf[k] != '\n' &&
  172.             j <= n) {
  173.             temp[j] = buf[k];
  174.             j++;
  175.             k++;
  176.         }
  177.     }
  178.     temp[j] = EOS;
  179.     while (buf[k] != delim && buf[k] != EOS && buf[k] != '\n')
  180.         k++;
  181.     *i = k;
  182.     return(j);
  183. }
  184.  
  185. /*
  186.  * jcopy - scopy without copying EOS
  187.  *
  188.  */
  189. jcopy(from, i, to, j)
  190. char from[];
  191. char to[];
  192. int i;
  193. int j;
  194. {
  195.     int k1, k2;
  196.     dprintf("jcopy  ");
  197.  
  198.     k1 = i;
  199.     k2 = j;
  200.     while (from[k1] != EOS) {
  201.         to[k2] = from[k1];
  202.         k1++;
  203.         k2++;
  204.     }
  205. }
  206.  
  207. /*
  208.  * justfy - justifies string in its tab column
  209.  * */
  210. justfy(in, left, right, type, out)
  211. char in[];
  212. char out[];
  213. int left;
  214. int right;
  215. int type;
  216. {
  217.     int j,k, n;
  218.  
  219.     dprintf("justfy  ");
  220.     n = width(in);
  221.     if (type == RIGHT)
  222.         jcopy(in, 0, out, right-n);
  223.     else if (type == CENTER) {
  224.         k = (right+left-n) / 2;
  225.         j = (k > left) ? k : left;
  226.         jcopy(in, 0, out, j);
  227.     }
  228.     else 
  229.         jcopy(in, 0, out, left);
  230. }
  231.  
  232. /*
  233.  * leadbl - delete leading blanks, set tival
  234.  *
  235.  */
  236. leadbl(buf)
  237. char buf[];
  238. {
  239.     int i, j;
  240.  
  241.     dprintf("leadbl  ");
  242.     brkeol();
  243.     for (i = 0; buf[i] == ' '; i++)     /* find 1st non-blank */
  244.         ;
  245.     if (buf[i] != '\n')
  246.         if (autopar) {
  247.             put("\n");    /* blank line */
  248.             tival = inval + autoprv;
  249.         }
  250.         else
  251.             tival = inval + i;        /* ??????????? */
  252.     for (j = 0; buf[i] != EOS; j++) {   /* move line to left */
  253.         buf[j] = buf[i];
  254.         i++;
  255.     }
  256.     buf[j] = EOS;
  257. }
  258.  
  259. /*
  260.  * ngetln - get next line from f into line
  261.  *
  262.  */
  263. int
  264. ngetln(line, f)
  265. char line[];
  266. FILE *f;
  267. {
  268.     int c, i;
  269.  
  270.     for (i = 0; (c = (bp >= 0) ? buf[bp--] : getc(f)) != EOF; ) {
  271.         if (i < MAXLINE - 1) {
  272.             line[i++] = (char) c;
  273.         }
  274.         if (c == '\n' || c == '\r')
  275.             break;
  276.     }
  277.     line[i] = EOS;
  278.     if (i == 0 && c == EOF)
  279.         i = EOF;
  280. #ifdef DEBUG
  281.     printf("ngetln: %s (line)\n",line);
  282. #endif
  283.     return(i);
  284. }
  285.  
  286. /*
  287.  * pbstr - push string back onto input
  288.  *
  289.  */
  290. pbstr(in)
  291. char in[];
  292. {
  293.  
  294.     int i;
  295.  
  296.     dprintf("pbstr  ");
  297.     for (i = strlen(in) - 1; i >= 0; i--)
  298.         putbak(in[i]);
  299. }
  300.  
  301. /*
  302.  * pfoot - put out page footer
  303.  *
  304.  */
  305. pfoot()
  306. {
  307.  
  308.     dprintf("pfoot  ");
  309.     skipl(m3val);
  310.     if (m4val > 0) {
  311.         if (curpag % 2 == 1)
  312.             puttl(efoot, eflim, curpag);
  313.         else
  314.             puttl(ofoot, oflim, curpag);
  315.     }
  316.     if (print == YES)        /* flush the page */
  317.     {
  318.         putchar(PAGEJECT);    /* ...          */
  319.         p_outpages++;
  320.         if (stopx > 0)        /* -s, so flush ^L*/
  321.             putchar('\n');
  322.     }
  323. }
  324.  
  325. /*
  326.  * phead - put out page header
  327.  *
  328.  */
  329. phead()
  330. {
  331.     dprintf("phead  ");
  332.  
  333.     curpag = newpag;
  334.     if (curpag >= frstpg && curpag <= lastpg)
  335.         print = YES;
  336.     else 
  337.         print = NO;
  338.     if(stopx > 0 && print == YES)
  339.         prmpt(&stopx);
  340.     newpag++;
  341.     if (m1val > 0) {
  342.         skipl(m1val-1);
  343.         if (curpag % 2 == 0)
  344.             puttl(ehead, ehlim, curpag);
  345.         else
  346.             puttl(ohead, ohlim, curpag);
  347.     }
  348.     skipl(m2val);
  349.     lineno = m1val + m2val + 1;
  350. }
  351.  
  352. /*
  353.  * prmpt - pause for paper insertion
  354.  * prompt if i == 1; increment i
  355.  *
  356.  */
  357. prmpt(i)
  358. int *i;
  359. {
  360.     int junk,j;
  361.     static char bellst[2] = { BEL, EOS};
  362.  
  363.     dprintf("prmpt  ");
  364.     j = *i;
  365.     if (j == 1)
  366. #ifdef rainbow
  367.         printf("%s\033[7minsert paper and type return\033[0m ",bellst);
  368. #else
  369.         printf("%sinsert paper and type return ",bellst);
  370. #endif
  371.     else
  372.         printf(bellst);
  373.     junk = getchar();
  374.     *i = ++j;
  375. }
  376.  
  377. /*
  378.  * Put - put out line with proper spacing and indenting
  379.  *
  380.  */
  381. put(buf)
  382. char buf[];
  383. {
  384.     register int i;
  385.     dprintf("put  ");
  386.     if (lineno == 0 || lineno > bottom)
  387.         phead();
  388.  
  389.     if ( print == YES ) {
  390.         if (buf[0] == '\n') {    /* empty line.. */
  391.             putchar('\n');
  392.             p_outlines++;
  393.         }
  394.         else {
  395.             for ( i = 1 ; i <= offset ; i++ ) /* page offset */
  396.                 putchar(' ');
  397.             for ( i = 1 ; i <= tival ; i++ )  /* indenting   */
  398.                 putchar(' ');
  399.  
  400.             while (*buf != '\0') {
  401.                 putchar(*buf);
  402.                 buf++;
  403.             }
  404.             p_outlines++;
  405.         }
  406.     }
  407.  
  408.     tival = inval;
  409.     skipl(((lsval-1 < bottom-lineno) ? lsval-1 : bottom-lineno));
  410.     lineno += lsval;
  411.  
  412.     if (lineno > bottom)
  413.         pfoot();
  414.  
  415. }
  416.  
  417. /*
  418.  * putbak - push character back onto input
  419.  *
  420.  */
  421. putbak(c)
  422. char c;
  423. {
  424.     dprintf("putbak  ");
  425.  
  426.     bp++;
  427.     if (bp > BUFSIZE)
  428.         error("too many characters pushed back.\n");
  429.     buf[bp] = c;
  430. }
  431.  
  432.  
  433. /*
  434.  * puttl - put out title line with optional page number & date
  435.  * 
  436.  */
  437. puttl(buf, lim, pageno)
  438. char buf[];
  439. int lim[];
  440. int pageno;
  441. {
  442.     char chars[9],cdate[27];
  443.     char rmstr[MAXTOK];
  444.     char delim;
  445.     char *tp;
  446.     int j;
  447.     int nc, n, i, left, right, ncd;
  448.  
  449.     dprintf("puttl  ");
  450.     if (print == NO)
  451.         return;
  452.     left = lim[0];    /* no more +1 here */
  453.     right = lim[1]; /* no more +1 here */
  454.     nc = itoc(pageno, chars, MAXCHARS);
  455.     if (roman) {
  456.         nc = cvtroman(chars,rmstr);
  457.         strcpy(chars,rmstr);
  458.     }
  459.     getnow(cdate);
  460.     ncd = strlen(cdate);
  461.     i = 0;
  462.     delim = buf[i];
  463.     for (j = 0; j < right; j++)
  464.         ttl[j] = ' ';
  465.     n = 0;
  466.     do {
  467.         if (gfield(buf, &i, right-left, tbuf1, delim) > 0) {
  468.             subst(tbuf1, PAGENUM, tbuf2, chars, nc);
  469.             subst(tbuf2, CURRENTDATE, tbuf1, cdate, ncd);
  470.             justfy(tbuf1, left, right, tjust[n], ttl);
  471.         }
  472.         n++;        /* update title counter */
  473.     } 
  474.     while (buf[i] != EOS && buf[i] != '\n' && n != 3);
  475.  
  476.     for( ; right >= 1 ; right--)
  477.         if( ttl[right-1] != ' ' )
  478.             break;
  479.     ttl[right] = '\n';
  480.     ttl[right+1] = EOS;
  481.     for (i = 1; i <= offset; i++)
  482.         putchar(' ');              /* offset */
  483.     tp = ttl;
  484.     while (*tp != '\0') {
  485.         putchar(*tp);
  486.         tp++;
  487.     }
  488.     p_outlines++;
  489. }
  490.  
  491. /*
  492.  * set - set parameter and check range
  493.  *
  494.  */
  495. set(param, val, argtyp, defval, minval, maxval)
  496. int *param;
  497. int val;
  498. int argtyp;
  499. int defval;
  500. int minval;
  501. int maxval;
  502. {
  503.     int i;
  504.     dprintf("set  ");
  505.     i = *param;
  506.     if (argtyp == '\n')              /* defaulted */
  507.         i = defval;
  508.     else if (argtyp == '+')                  /* relative +*/
  509.         i += val;
  510.     else if (argtyp == '-')           /* relative -*/
  511.         i -= val;
  512.     else                           /* absolute  */
  513.     i = val;
  514.     i = (i < maxval) ? i : maxval;         /* min          */
  515.     i = (i > minval) ? i : minval;         /* max          */
  516.     *param = i;
  517. }
  518.  
  519. /*
  520. * skipl - output  n  blank lines
  521. *
  522. */
  523. skipl(n)
  524. register int n;
  525. {
  526.     register int i;
  527.  
  528.     dprintf("skip  ");
  529.     if (print == YES)
  530.         for (i = 1; i <= n; i++) {
  531.             putchar('\n');
  532.             p_outlines++;
  533.         }
  534. }
  535.  
  536. /*
  537.  * space - space  n  lines or to bottom of page
  538.  *
  539.  */
  540. space(n)
  541. int n;
  542. {
  543.  
  544.     dprintf("space  ");
  545.     brkeol();
  546.     if (lineno > bottom)
  547.         return;
  548.     if (lineno == 0)
  549.         phead();
  550.     skipl(((n < bottom+1-lineno) ? n : bottom+1-lineno));
  551.     lineno += n;
  552.     if (lineno > bottom)
  553.         pfoot();
  554. }
  555.  
  556. /*
  557.  * spread - spread words to justify right margin
  558.  *
  559.  */
  560. spread(buf, outp, nextra, outwds)
  561. char buf[];
  562. int outp;
  563. int nextra;
  564. int outwds;
  565. {
  566.     int dir = 0;
  567.  
  568.     register int i, j;
  569.     int nb, ne, nholes;
  570.  
  571.     dprintf("spread  ");
  572.     if (nextra <= 0 || outwds <= 1)
  573.         return;
  574.     dir = 1 - dir;   /* reverse previous direction */
  575.     ne = nextra;
  576.     nholes = outwds - 1;
  577.     if (tival != inval && nholes > 1)
  578.         nholes--;
  579.     i = outp - 1;
  580.     j = (MAXOUT-2 < i+ne) ? MAXOUT-2 : i+ne; /* leave room for '\n', EOS */
  581.     while (i < j) {
  582.         buf[j] = buf[i];
  583.         if (buf[i] == ' ' && buf[i-1] != ' ') {
  584.             if (dir == 0)
  585.                 nb = (ne-1) / nholes + 1;
  586.             else
  587.                 nb = ne / nholes;
  588.             ne -= nb;
  589.             nholes--;
  590.             for ( ; nb > 0; nb--) {
  591.                 j--;
  592.                 buf[j] = ' ';
  593.             }
  594.         }
  595.         i--;
  596.         j--;
  597.     }
  598. }
  599.  
  600. /*
  601.  * subst - substitutes a string for a specified character
  602.  *
  603.  */
  604. subst(in, chr, out, subara, n)
  605. char in[];
  606. char chr;
  607. char out[];
  608. char subara[];
  609. int n;
  610. {
  611.     register int i, j, k;
  612.  
  613.     dprintf("subst  ");
  614.     j = 0;
  615.     for (i = 0; in[i] != EOS; i++)
  616.         if (in[i] == chr)
  617.             for (k = 0; k < n; k++) {
  618.                 out[j] = subara[k];
  619.                 j++;
  620.             }
  621.         else {
  622.             out[j] = in[i];
  623.             j++;
  624.         }
  625.     out[j] = EOS;
  626. }
  627.  
  628. /*
  629.  * Text    process text lines
  630.  *
  631.  */
  632.  
  633. text(inbuf)
  634. char inbuf[];
  635. {
  636.     int    i;
  637.     register int j;
  638.     char    wrdbuf[INSIZE];
  639.  
  640.     dovar(wrdbuf,inbuf);        /*  expand variables */
  641.     strcpy(inbuf,wrdbuf);
  642.     doesc(inbuf, wrdbuf, INSIZE);    /*  expand escapes   */
  643.     dotabs(inbuf, wrdbuf, INSIZE);  /*  expand tabs      */
  644.  
  645.     if(inbuf[0] == ' ' || inbuf[0] == '\n')
  646.         leadbl(inbuf);         /* move left, set tival */
  647.     if(ulval > 0 || ULon)         /* word underlining */
  648.     {
  649.         underl(inbuf, wrdbuf, INSIZE);
  650.         ulval--;
  651.     }
  652.     if(boval > 0 || BDon)         /* boldfacing */
  653.     {
  654.         bold( inbuf, wrdbuf, INSIZE);
  655.         boval--;
  656.     }
  657.     if(ceval > 0 || CEon)         /* centering */
  658.     {
  659.         center(inbuf);
  660.         put(inbuf);
  661.         ceval--;
  662.     }
  663.     else if( inbuf[0] == '\n' )     /* all blank line */
  664.         put(inbuf);
  665.     else if( fill == NO )         /* unfilled text */
  666.         put(inbuf);
  667.     else                 /* filled text */
  668.     {
  669.         i = strlen(inbuf) - 1;
  670.         inbuf[i] = ' ';
  671.         if( inbuf[i-1] == '.' )
  672.         {
  673.             i++;
  674.             inbuf[i] = ' ';
  675.         }
  676.         inbuf[i+1] = EOS;
  677.         for( i = 0 ; getwrb(inbuf, &i, wrdbuf) > 0 ; )
  678.             putwrd(wrdbuf);
  679.     }
  680. }
  681.  
  682. /*
  683.  * Underl    underline words in a line
  684.  *
  685.  */
  686. underl(buf, tbuf, size)
  687. char buf[];
  688. char tbuf[];
  689. int size;
  690. {
  691.     int i, j;
  692.  
  693.     j = 0;
  694.     for(i = 0 ; buf[i] != '\n' && j < size - 2; i++) {
  695.         if( buf[i] != ' ' && buf[i] != BACKSPACE && buf[i] != '_' ) {
  696.             tbuf[j++] = '_';
  697.             tbuf[j++] = BACKSPACE;
  698.         }
  699.         if( buf[i] == BLANK )
  700.             tbuf[j++] = ulblnk;
  701.         else
  702.             tbuf[j++] = buf[i];
  703.     }
  704.  
  705.     tbuf[j] = '\n';
  706.     tbuf[j+1] = '\0';
  707.     strcpy(buf, tbuf);
  708. }
  709.  
  710. /*
  711.  * width - compute width of character string
  712.  *
  713.  */
  714. int
  715. width(buf)
  716. char buf[];
  717. {
  718.     int k,i;
  719.  
  720.     dprintf("width  ");
  721.     k = 0;
  722.     for (i = 0; buf[i] != EOS; i++)
  723.         if (buf[i] == BACKSPACE)
  724.             k--;
  725.         else if (buf[i] >= ' ' && buf[i] <= '~')
  726.             k++;
  727.     return(k);
  728. }
  729. /*
  730.  * getnow - get the date from command line if present.
  731.  *          if not specified, prompt user for it.
  732.  *
  733.  * (stub)
  734.  */
  735. getnow(date)
  736. char date[];
  737. {
  738.     dprintf("getnow  ");
  739.     strcpy(date,"00-xxx-1900 00:00:00");
  740. }
  741.